/**
 * 工具函数集合
 */

/**
 * 解析日期字符串为Date对象
 * @param {string|Date} dateInput - 日期字符串或日期对象
 * @returns {Date} 解析后的日期对象，如果解析失败返回当前日期
 */
const parseDate = dateInput => {
  // 如果已经是Date对象，直接返回
  if (dateInput instanceof Date) {
    return isNaN(dateInput.getTime()) ? new Date() : dateInput;
  }
  
  // 如果是null或undefined，返回当前日期
  if (!dateInput) {
    return new Date();
  }
  
  let date;
  
  // 处理字符串类型的日期
  if (typeof dateInput === 'string') {
    // 替换连字符"-"为斜杠"/"，以兼容iOS
    const normalized = dateInput.replace(/-/g, '/').replace('T', ' ');
    
    try {
      date = new Date(normalized);
      
      // 检查是否是有效日期
      if (isNaN(date.getTime())) {
        console.warn('无效的日期格式:', dateInput);
        date = new Date();
      }
    } catch (e) {
      console.error('日期解析错误:', e, dateInput);
      date = new Date();
    }
  } else {
    // 其他类型，尝试转换为日期
    try {
      date = new Date(dateInput);
      if (isNaN(date.getTime())) {
        console.warn('无法转换为日期:', dateInput);
        date = new Date();
      }
    } catch (e) {
      console.error('日期转换错误:', e, dateInput);
      date = new Date();
    }
  }
  
  return date;
};

/**
 * 格式化时间为完整时间格式 YYYY/MM/DD HH:mm:ss
 * @param {Date|string} date - 日期对象或日期字符串
 * @returns {string} 格式化后的时间字符串
 */
const formatTime = date => {
  date = parseDate(date);
  
  const year = date.getFullYear();
  const month = date.getMonth() + 1;
  const day = date.getDate();
  const hour = date.getHours();
  const minute = date.getMinutes();
  const second = date.getSeconds();

  return [year, month, day].map(formatNumber).join('/') + ' ' + [hour, minute, second].map(formatNumber).join(':');
};

/**
 * 格式化数字，保证两位数
 * @param {number} n - 需要格式化的数字
 * @returns {string} 格式化后的字符串
 */
const formatNumber = n => {
  n = n.toString();
  return n[1] ? n : '0' + n;
};

/**
 * 格式化日期为YYYY-MM-DD
 * @param {Date|string} date - 日期对象或日期字符串
 * @returns {string} 格式化后的日期字符串
 */
const formatDate = date => {
  date = parseDate(date);
  
  const year = date.getFullYear();
  const month = date.getMonth() + 1;
  const day = date.getDate();

  return [year, month, day].map(formatNumber).join('-');
};

/**
 * 格式化日期时间为YYYY-MM-DD HH:mm
 * @param {Date|string} date - 日期对象或日期字符串
 * @returns {string} 格式化后的日期时间字符串
 */
const formatDateTime = date => {
  date = parseDate(date);
  
  const year = date.getFullYear();
  const month = date.getMonth() + 1;
  const day = date.getDate();
  const hour = date.getHours();
  const minute = date.getMinutes();

  return [year, month, day].map(formatNumber).join('-') + ' ' + [hour, minute].map(formatNumber).join(':');
};

/**
 * 计算年龄，返回岁和月
 * @param {string|Date} birthdate - 出生日期字符串或日期对象
 * @returns {string} 年龄字符串
 */
const calculateAge = birthdate => {
  if (!birthdate) return '';
  
  const today = new Date();
  const birthDate = parseDate(birthdate);
  
  let years = today.getFullYear() - birthDate.getFullYear();
  let months = today.getMonth() - birthDate.getMonth();
  
  if (months < 0) {
    years--;
    months += 12;
  }
  
  let ageText = '';
  if (years > 0) {
    ageText = `${years}岁`;
    if (months > 0) {
      ageText += `${months}个月`;
    }
  } else {
    ageText = `${months}个月`;
  }
  
  return ageText;
};

/**
 * 格式化友好的时间显示
 * @param {string|Date} timeStr - 时间字符串或日期对象
 * @returns {string} 友好格式的时间
 */
const formatFriendlyTime = timeStr => {
  if (!timeStr) return '';
  
  const date = parseDate(timeStr);
  const now = new Date();
  const diff = now - date; // 时间差（毫秒）
  
  // 一小时内
  if (diff < 60 * 60 * 1000) {
    const minutes = Math.floor(diff / (60 * 1000));
    return minutes <= 0 ? '刚刚' : `${minutes}分钟前`;
  }
  
  // 一天内
  if (diff < 24 * 60 * 60 * 1000) {
    const hours = Math.floor(diff / (60 * 60 * 1000));
    return `${hours}小时前`;
  }
  
  // 一周内
  if (diff < 7 * 24 * 60 * 60 * 1000) {
    const days = ['周日', '周一', '周二', '周三', '周四', '周五', '周六'];
    return days[date.getDay()];
  }
  
  // 一年内
  if (date.getFullYear() === now.getFullYear()) {
    return `${date.getMonth() + 1}月${date.getDate()}日`;
  }
  
  // 更早
  return `${date.getFullYear()}年${date.getMonth() + 1}月${date.getDate()}日`;
};

/**
 * 将秒数转换为分:秒格式
 * @param {number} seconds - 秒数
 * @returns {string} 分:秒格式的字符串
 */
const formatDuration = seconds => {
  const minutes = Math.floor(seconds / 60);
  const remainingSeconds = Math.floor(seconds % 60);
  return `${formatNumber(minutes)}:${formatNumber(remainingSeconds)}`;
};

/**
 * 检查对象是否为空
 * @param {object} obj - 要检查的对象
 * @returns {boolean} 是否为空
 */
const isEmptyObject = obj => {
  return obj === null || obj === undefined || Object.keys(obj).length === 0;
};

/**
 * 限制字符串长度，超出部分用省略号代替
 * @param {string} str - 原字符串
 * @param {number} length - 限制长度
 * @returns {string} 处理后的字符串
 */
const truncateString = (str, length = 10) => {
  if (!str) return '';
  return str.length > length ? str.substring(0, length) + '...' : str;
};

/**
 * 深拷贝对象
 * @param {object} obj - 需要拷贝的对象
 * @returns {object} 拷贝后的新对象
 */
const deepClone = obj => {
  if (obj === null || typeof obj !== 'object') return obj;
  const clone = Array.isArray(obj) ? [] : {};
  for (let key in obj) {
    if (Object.prototype.hasOwnProperty.call(obj, key)) {
      clone[key] = deepClone(obj[key]);
    }
  }
  return clone;
};

/**
 * 生成随机字符串
 * @param {number} length - 字符串长度
 * @returns {string} 随机字符串
 */
const randomString = (length = 6) => {
  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
  let result = '';
  for (let i = 0; i < length; i++) {
    result += chars.charAt(Math.floor(Math.random() * chars.length));
  }
  return result;
};

/**
 * 处理图片URL，确保返回可访问的URL
 * @param {string} imageUrl - 原始图片URL
 * @returns {string} 处理后的图片URL
 */
const getImageUrl = imageUrl => {
  if (!imageUrl) return '';
  
  // 如果是本地路径（以/static开头），直接返回
  if (imageUrl.startsWith('/static')) {
    return imageUrl;
  }
  
  // 如果是完整URL（包含http或https），直接返回
  if (imageUrl.startsWith('http://') || imageUrl.startsWith('https://')) {
    return imageUrl;
  }
  
  // 如果是相对路径（以/uploads开头），拼接服务器地址
  if (imageUrl.startsWith('/uploads')) {
    // 获取全局配置的baseUrl
    const app = getApp();
    const baseUrl = app ? app.globalData.baseUrl : 'http://localhost:8080/api';
    return baseUrl + imageUrl;
  }
  
  // 其他情况，返回原始URL
  return imageUrl;
};

module.exports = {
  formatTime,
  formatNumber,
  formatDate,
  formatDateTime,
  calculateAge,
  formatFriendlyTime,
  formatDuration,
  isEmptyObject,
  truncateString,
  deepClone,
  randomString,
  getImageUrl,
  parseDate
}; 